home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / AMT / Moonbase Engine / Moonbase Engine 1.2 / Moonbase Engine Sources / keyMoonbase / Engine / MoonbaseSenderModels.c < prev    next >
Encoding:
Text File  |  1996-02-22  |  5.4 KB  |  214 lines  |  [TEXT/MPS ]
  1. //
  2. //    File: MoonbaseSenderModels.c
  3. //    Project: Moonbase Engine
  4. //    Copyright: (c) 1996 Moonbase Enterprises Pty Ltd (ACN 072 298 554)
  5. //
  6.  
  7. #include <key.h>
  8.  
  9. extern const keyID K_X;
  10. extern const keyID K_Y;
  11. extern const keyID K_TIME;
  12. extern const keyID K_MAXIMUMTIME;
  13. extern const keyID K_USEMAXIMUMTIME;
  14.  
  15. extern const keyID K_READATOM;
  16. extern const keyID K_WEIGHATOM;
  17. extern const keyID K_WRITEATOM;
  18.  
  19. //
  20. //    5390    Scroll by
  21. //
  22.  
  23. #define kScrollBySenderAtomType 'scby'
  24. typedef struct {
  25.     long atomSize;
  26.     unsigned long atomType;
  27.     short x;
  28.     short y;
  29. } ScrollBySenderAtom;
  30.  
  31. void oScrollBySenderModelRead(key* the)
  32. {
  33.     ScrollBySenderAtom anAtom;
  34.     
  35.     anAtom.atomSize = sizeof(ScrollBySenderAtom);
  36.     anAtom.atomType = kScrollBySenderAtomType;
  37.     keyCall1(the[ARGUMENT(1)], K_READATOM, keyFromPointer(&anAtom));
  38.     keyPut(the[SELF], K_X, keyFromInteger(anAtom.x));
  39.     keyPut(the[SELF], K_Y, keyFromInteger(anAtom.y));
  40. }
  41.  
  42. void oScrollBySenderModelWeigh(key* the)
  43. {
  44.     keyCall1(the[ARGUMENT(1)], K_WEIGHATOM, keyFromInteger(sizeof(ScrollBySenderAtom)));
  45. }
  46.  
  47. void oScrollBySenderModelWrite(key* the)
  48. {
  49.     ScrollBySenderAtom anAtom;
  50.  
  51.     anAtom.atomSize = sizeof(ScrollBySenderAtom);
  52.     anAtom.atomType = kScrollBySenderAtomType;
  53.     anAtom.x = keyToInteger(keyGet(the[SELF], K_X));
  54.     anAtom.y = keyToInteger(keyGet(the[SELF], K_Y));
  55.     keyCall1(the[ARGUMENT(1)], K_WRITEATOM, keyFromPointer(&anAtom));
  56. }
  57.  
  58. //
  59. //    5391    Scroll to
  60. //
  61.  
  62. #define kScrollToSenderAtomType 'scto'
  63. typedef struct {
  64.     long atomSize;
  65.     unsigned long atomType;
  66.     short x;
  67.     short y;
  68. } ScrollToSenderAtom;
  69.  
  70. void oScrollToSenderModelRead(key* the)
  71. {
  72.     ScrollToSenderAtom anAtom;
  73.     
  74.     anAtom.atomSize = sizeof(ScrollToSenderAtom);
  75.     anAtom.atomType = kScrollToSenderAtomType;
  76.     keyCall1(the[ARGUMENT(1)], K_READATOM, keyFromPointer(&anAtom));
  77.     keyPut(the[SELF], K_X, keyFromInteger(anAtom.x));
  78.     keyPut(the[SELF], K_Y, keyFromInteger(anAtom.y));
  79. }
  80.  
  81. void oScrollToSenderModelWeigh(key* the)
  82. {
  83.     keyCall1(the[ARGUMENT(1)], K_WEIGHATOM, keyFromInteger(sizeof(ScrollToSenderAtom)));
  84. }
  85.  
  86. void oScrollToSenderModelWrite(key* the)
  87. {
  88.     ScrollToSenderAtom anAtom;
  89.  
  90.     anAtom.atomSize = sizeof(ScrollToSenderAtom);
  91.     anAtom.atomType = kScrollToSenderAtomType;
  92.     anAtom.x = keyToInteger(keyGet(the[SELF], K_X));
  93.     anAtom.y = keyToInteger(keyGet(the[SELF], K_Y));
  94.     keyCall1(the[ARGUMENT(1)], K_WRITEATOM, keyFromPointer(&anAtom));
  95. }
  96.  
  97. //
  98. //    5392    Scroll to Cell
  99. //
  100.  
  101. #define kScrollToCellSenderAtomType 'sctc'
  102. typedef struct {
  103.     long atomSize;
  104.     unsigned long atomType;
  105.     short x;
  106.     short y;
  107. } ScrollToCellSenderAtom;
  108.  
  109. void oScrollToCellSenderModelRead(key* the)
  110. {
  111.     ScrollToCellSenderAtom anAtom;
  112.     
  113.     anAtom.atomSize = sizeof(ScrollToCellSenderAtom);
  114.     anAtom.atomType = kScrollToCellSenderAtomType;
  115.     keyCall1(the[ARGUMENT(1)], K_READATOM, keyFromPointer(&anAtom));
  116.     keyPut(the[SELF], K_X, keyFromInteger(anAtom.x));
  117.     keyPut(the[SELF], K_Y, keyFromInteger(anAtom.y));
  118. }
  119.  
  120. void oScrollToCellSenderModelWeigh(key* the)
  121. {
  122.     keyCall1(the[ARGUMENT(1)], K_WEIGHATOM, keyFromInteger(sizeof(ScrollToCellSenderAtom)));
  123. }
  124.  
  125. void oScrollToCellSenderModelWrite(key* the)
  126. {
  127.     ScrollToCellSenderAtom anAtom;
  128.  
  129.     anAtom.atomSize = sizeof(ScrollToCellSenderAtom);
  130.     anAtom.atomType = kScrollToCellSenderAtomType;
  131.     anAtom.x = keyToInteger(keyGet(the[SELF], K_X));
  132.     anAtom.y = keyToInteger(keyGet(the[SELF], K_Y));
  133.     keyCall1(the[ARGUMENT(1)], K_WRITEATOM, keyFromPointer(&anAtom));
  134. }
  135.  
  136. //
  137. //    5393    Set Duration
  138. //
  139.  
  140. #define kSetDurationSenderAtomType 'sedu'
  141. typedef struct {
  142.     long atomSize;
  143.     unsigned long atomType;
  144.     long time;
  145.     long maximumtime;
  146.     unsigned char usemaximumtime;
  147.     unsigned char filler;
  148. } SetDurationSenderAtom;
  149.  
  150. void oSetDurationSenderModelRead(key* the)
  151. {
  152.     SetDurationSenderAtom anAtom;
  153.     
  154.     anAtom.atomSize = sizeof(SetDurationSenderAtom);
  155.     anAtom.atomType = kSetDurationSenderAtomType;
  156.     keyCall1(the[ARGUMENT(1)], K_READATOM, keyFromPointer(&anAtom));
  157.     keyPut(the[SELF], K_TIME, keyFromInteger(anAtom.time));
  158.     keyPut(the[SELF], K_MAXIMUMTIME, keyFromInteger(anAtom.maximumtime));
  159.     keyPut(the[SELF], K_USEMAXIMUMTIME, keyFromBoolean(anAtom.usemaximumtime));
  160. }
  161.  
  162. void oSetDurationSenderModelWeigh(key* the)
  163. {
  164.     keyCall1(the[ARGUMENT(1)], K_WEIGHATOM, keyFromInteger(sizeof(SetDurationSenderAtom)));
  165. }
  166.  
  167. void oSetDurationSenderModelWrite(key* the)
  168. {
  169.     SetDurationSenderAtom anAtom;
  170.  
  171.     anAtom.atomSize = sizeof(SetDurationSenderAtom);
  172.     anAtom.atomType = kSetDurationSenderAtomType;
  173.     anAtom.time = keyToInteger(keyGet(the[SELF], K_TIME));
  174.     anAtom.maximumtime = keyToInteger(keyGet(the[SELF], K_MAXIMUMTIME));
  175.     anAtom.usemaximumtime = keyToBoolean(keyGet(the[SELF], K_USEMAXIMUMTIME));
  176.     keyCall1(the[ARGUMENT(1)], K_WRITEATOM, keyFromPointer(&anAtom));
  177. }
  178.  
  179. //
  180. //    5394    Step by Time
  181. //
  182.  
  183. #define kStepByTimeSenderAtomType 'stby'
  184. typedef struct {
  185.     long atomSize;
  186.     unsigned long atomType;
  187.     long time;
  188. } StepByTimeSenderAtom;
  189.  
  190. void oStepByTimeSenderModelRead(key* the)
  191. {
  192.     StepByTimeSenderAtom anAtom;
  193.     
  194.     anAtom.atomSize = sizeof(StepByTimeSenderAtom);
  195.     anAtom.atomType = kStepByTimeSenderAtomType;
  196.     keyCall1(the[ARGUMENT(1)], K_READATOM, keyFromPointer(&anAtom));
  197.     keyPut(the[SELF], K_TIME, keyFromInteger(anAtom.time));
  198. }
  199.  
  200. void oStepByTimeSenderModelWeigh(key* the)
  201. {
  202.     keyCall1(the[ARGUMENT(1)], K_WEIGHATOM, keyFromInteger(sizeof(StepByTimeSenderAtom)));
  203. }
  204.  
  205. void oStepByTimeSenderModelWrite(key* the)
  206. {
  207.     StepByTimeSenderAtom anAtom;
  208.  
  209.     anAtom.atomSize = sizeof(StepByTimeSenderAtom);
  210.     anAtom.atomType = kStepByTimeSenderAtomType;
  211.     anAtom.time = keyToInteger(keyGet(the[SELF], K_TIME));
  212.     keyCall1(the[ARGUMENT(1)], K_WRITEATOM, keyFromPointer(&anAtom));
  213. }
  214.